JavaScript WeakMap ja WeakSet: mälu-efektiivsete kollektsioonide valdamine

JavaScript pakub mitmeid sisseehitatud andmestruktuure andmekogumite haldamiseks. Kuigi standardsed Map ja Set pakuvad võimsaid tööriistu, võivad need mõnikord põhjustada mälulekkeid, eriti keerukates rakendustes. Siin tulevadki mängu WeakMap ja WeakSet. Need spetsialiseeritud kollektsioonid pakuvad ainulaadset lähenemist mäluhaldusele, võimaldades JavaScripti prügikoristajal mälu tõhusamalt tagasi nõuda.

Probleemi mõistmine: tugevad viited

Enne WeakMap'i ja WeakSet'i süvenemist mõistame põhiprobleemi: tugevad viited. JavaScriptis, kui objekt salvestatakse Map'i võtmena või Set'i väärtusena, säilitab kollektsioon selle objekti suhtes tugeva viite. See tähendab, et seni, kuni Map või Set eksisteerib, ei saa prügikoristaja objekti poolt hõivatud mälu tagasi nõuda, isegi kui objektile ei viidata enam kuskil mujal teie koodis. See võib põhjustada mälulekkeid, eriti suurte või pikaealiste kollektsioonidega tegelemisel.

Vaatleme seda näidet:

            let myMap = new Map();
let key = { id: 1, name: "Example Object" };

myMap.set(key, "Some value");

// Even if 'key' is no longer used directly...
key = null;

// ... the Map still holds a reference to it.
console.log(myMap.size); // Output: 1

            

              
                Copy
              
            
          

Selles stsenaariumis, isegi pärast key väärtuseks null seadmist, hoiab Map endiselt viidet algsele objektile. Prügikoristaja ei saa selle objekti kasutatud mälu tagasi nõuda, sest Map takistab seda.

Tutvustame WeakMap'i ja WeakSet'i: nõrgad viited appi

WeakMap ja WeakSet lahendavad selle probleemi, kasutades nõrku viiteid. Nõrk viide võimaldab objekti prügikoristada, kui sellele pole muid tugevaid viiteid. Kui WeakMap'i võtmele või WeakSet'i väärtusele viidatakse ainult nõrgalt, on prügikoristajal vabadus mälu tagasi nõuda. Kui objekt on prügikoristatud, eemaldatakse vastav kirje automaatselt WeakMap'ist või WeakSet'ist.

WeakMap: võti-väärtus paarid nõrkade võtmetega

WeakMap on võti-väärtus paaride kollektsioon, kus võtmed peavad olema objektid. Võtmeid hoitakse nõrgalt, mis tähendab, et kui võtmeobjektile mujal enam ei viidata, saab selle prügikoristada ja vastav kirje eemaldatakse WeakMap'ist. Väärtusi hoitakse seevastu tavaliste (tugevate) viidetega.

Siin on lihtne näide:

            let weakMap = new WeakMap();
let key = { id: 1, name: "WeakMap Key" };
let value = "Associated Data";

weakMap.set(key, value);

console.log(weakMap.get(key)); // Output: "Associated Data"

key = null;

// Pärast prügikoristust (mis ei pruugi kohe toimuda)...
// weakMap.get(key) võib tagastada undefined. See sõltub implementatsioonist.
// Me ei saa otse jälgida, millal kirje WeakMap'ist eemaldatakse, mis on taotluslik.

            

              
                Copy
              
            
          

Põhierinevused Map'ist:

• Võtmed peavad olema objektid: Ainult objekte saab kasutada WeakMap'i võtmetena. Primitiivsed väärtused (sõned, numbrid, tõeväärtused, sümbolid) ei ole lubatud. See on sellepärast, et primitiivsed väärtused on muutumatud ja ei vaja prügikoristust samamoodi nagu objektid.
• Itereerimine puudub: Te ei saa itereerida üle WeakMap'i võtmete, väärtuste ega kirjete. Puuduvad meetodid nagu forEach, keys(), values() või entries(). See on sellepärast, et nende meetodite olemasolu nõuaks WeakMap'ilt tugeva viite säilitamist oma võtmetele, mis nulliks nõrkade viidete eesmärgi.
• Puudub 'size' omadus: WeakMap'il ei ole size omadust. Suuruse määramine nõuaks samuti võtmete üle itereerimist, mis pole lubatud.
• Piiratud meetodid: WeakMap pakub ainult meetodeid get(key), set(key, value), has(key) ja delete(key).

WeakSet: nõrgalt hoitavate objektide kollektsioon

WeakSet sarnaneb Set'ile, kuid see lubab väärtustena salvestada ainult objekte. Nagu WeakMap, hoiab ka WeakSet neid objekte nõrgalt. Kui WeakSet'is olevale objektile ei viidata enam kuskil mujal tugevalt, saab selle prügikoristada ja WeakSet eemaldab objekti automaatselt.

Siin on lihtne näide:

            let weakSet = new WeakSet();
let obj1 = { id: 1, name: "Object 1" };
let obj2 = { id: 2, name: "Object 2" };

weakSet.add(obj1);
weakSet.add(obj2);

console.log(weakSet.has(obj1)); // Output: true

obj1 = null;

// Pärast prügikoristust (ei ole kohe garanteeritud)...
// weakSet.has(obj1) võib tagastada false. See sõltub implementatsioonist.
// Me ei saa otse jälgida, millal element WeakSet'ist eemaldatakse.

            

              
                Copy
              
            
          

Põhierinevused Set'ist:

• Väärtused peavad olema objektid: Ainult objekte saab salvestada WeakSet'i. Primitiivsed väärtused ei ole lubatud.
• Itereerimine puudub: Te ei saa itereerida üle WeakSet'i. Puudub forEach meetod või muud vahendid elementidele ligipääsemiseks.
• Puudub 'size' omadus: WeakSet'il ei ole size omadust.
• Piiratud meetodid: WeakSet pakub ainult meetodeid add(value), has(value) ja delete(value).

WeakMap'i ja WeakSet'i praktilised kasutusjuhud

WeakMap'i ja WeakSet'i piirangud võivad jätta mulje, et need on vähem mitmekülgsed kui nende tugevamad vasted. Siiski muudavad nende ainulaadsed mäluhalduse võimekused nad teatud stsenaariumides hindamatuks.

1. DOM elementide metaandmed

Levinud kasutusjuht on metaandmete seostamine DOM-i elementidega ilma DOM-i ennast saastamata. Näiteks võite soovida salvestada konkreetse HTML-elemendiga seotud komponendipõhiseid andmeid. Kasutades WeakMap'i, saate tagada, et kui DOM-element lehelt eemaldatakse, prügikoristatakse ka sellega seotud metaandmed, vältides nii mälulekkeid.

            let elementData = new WeakMap();

function initializeComponent(element) {
  let componentData = {
    // Komponendipõhised andmed
    isActive: false,
    onClick: () => { console.log("Clicked!"); }
  };
  elementData.set(element, componentData);
}

let myElement = document.getElementById("myElement");
initializeComponent(myElement);

// Hiljem, kui element DOM-ist eemaldatakse:
// myElement.remove();

// myElement'iga seotud componentData prügikoristatakse lõpuks
// kui myElement'ile pole muid tugevaid viiteid.

            

              
                Copy
              
            
          

Selles näites salvestab elementData DOM-i elementidega seotud metaandmeid. Kui myElement eemaldatakse DOM-ist, saab prügikoristaja selle mälu tagasi nõuda ja vastav kirje elementData's eemaldatakse automaatselt.

2. Kulukate operatsioonide tulemuste vahemällu salvestamine

Saate kasutada WeakMap'i kulukate operatsioonide tulemuste vahemällu salvestamiseks, tuginedes sisendobjektidele. Kui sisendobjekti enam ei kasutata, eemaldatakse vahemällu salvestatud tulemus automaatselt WeakMap'ist, vabastades mälu.

            let cache = new WeakMap();

function expensiveOperation(input) {
  if (cache.has(input)) {
    console.log("Vahemälu tabamus!");
    return cache.get(input);
  }

  console.log("Vahemälust möödalask!");
  // Soorita kulukas operatsioon
  let result = input.id * 100;

  cache.set(input, result);
  return result;
}

let obj1 = { id: 5 };
let obj2 = { id: 10 };

console.log(expensiveOperation(obj1)); // Output: Cache miss!, 500
console.log(expensiveOperation(obj1)); // Output: Cache hit!, 500
console.log(expensiveOperation(obj2)); // Output: Cache miss!, 1000

obj1 = null;

// Pärast prügikoristust eemaldatakse obj1 kirje vahemälust.

            

              
                Copy
              
            
          

3. Objektide privaatsed andmed (WeakMap privaatsete väljadena)

Enne privaatsete klassiväljade kasutuselevõttu JavaScriptis oli WeakMap levinud tehnika objektide sees privaatsete andmete simuleerimiseks. Iga objekt seostati oma privaatsete andmetega, mis salvestati WeakMap'i. Kuna andmetele pääseb ligi ainult WeakMap'i ja objekti enda kaudu, on need tegelikult privaatsed.

            let _privateData = new WeakMap();

class MyClass {
  constructor(secret) {
    _privateData.set(this, { secret: secret });
  }

  getSecret() {
    return _privateData.get(this).secret;
  }
}

let instance = new MyClass("My Secret Value");
console.log(instance.getSecret()); // Output: My Secret Value

// Otse _privateData'le ligipääsemine ei toimi.
// console.log(_privateData.get(instance).secret); // Viga (kui teil oleks kuidagi juurdepääs _privateData'le)

// Isegi kui isend prügikoristatakse, eemaldatakse vastav kirje _privateData's.

            

              
                Copy
              
            
          

Kuigi tänapäeval on eelistatud lähenemine privaatsed klassiväljad, on selle WeakMap'i mustri mõistmine endiselt väärtuslik vanema koodi ja JavaScripti ajaloo mõistmiseks.

4. Objekti elutsükli jälgimine

WeakSet'i saab kasutada objektide elutsükli jälgimiseks. Saate lisada objekte WeakSet'i nende loomisel ja seejärel kontrollida, kas need on endiselt WeakSet'is olemas. Kui objekt prügikoristatakse, eemaldatakse see automaatselt WeakSet'ist.

            let trackedObjects = new WeakSet();

function trackObject(obj) {
  trackedObjects.add(obj);
}

function isObjectTracked(obj) {
  return trackedObjects.has(obj);
}

let myObject = { id: 123 };
trackObject(myObject);

console.log(isObjectTracked(myObject)); // Output: true

myObject = null;

// Pärast prügikoristust võib isObjectTracked(myObject) tagastada false.

            

              
                Copy
              
            
          

Üldised kaalutlused ja parimad praktikad

Töötades WeakMap'i ja WeakSet'iga, arvestage järgmiste üldiste parimate tavadega:

• Mõistke prügikoristust: Prügikoristus ei ole deterministlik. Te ei saa täpselt ennustada, millal objekt prügikoristatakse. Seetõttu ei saa te loota, et WeakMap või WeakSet eemaldavad kirjed kohe, kui objektile enam ei viidata.
• Vältige liigset kasutamist: Kuigi WeakMap ja WeakSet on mäluhalduseks kasulikud, ärge kasutage neid liiga palju. Paljudel juhtudel on standardsed Map ja Set täiesti piisavad ja pakuvad rohkem paindlikkust. Kasutage WeakMap'i ja WeakSet'i siis, kui vajate spetsiifiliselt nõrku viiteid mälulekete vältimiseks.
• Nõrkade viidete kasutusjuhud: Mõelge selle objekti elueale, mida salvestate võtmena (WeakMap'i puhul) või väärtusena (WeakSet'i puhul). Kui objekt on seotud teise objekti elutsükliga, kasutage mälulekete vältimiseks WeakMap'i või WeakSet'i.
• Testimise väljakutsed: Prügikoristusest sõltuva koodi testimine võib olla keeruline. JavaScriptis ei saa prügikoristust sundida. Kaaluge tehnikate kasutamist, nagu suurte objektide arvu loomine ja hävitamine, et soodustada prügikoristust testimise ajal.
• Polyfill'id: Kui peate toetama vanemaid brausereid, mis ei toeta loomulikult WeakMap'i ja WeakSet'i, võite kasutada polyfill'e. Siiski ei pruugi polyfill'id suuta nõrga viite käitumist täielikult jäljendada, seega testige põhjalikult.

Näide: Rahvusvahelistamise (i18n) vahemälu

Kujutage ette stsenaariumi, kus ehitate rahvusvahelistamise (i18n) toega veebirakendust. Võiksite soovida tõlgitud sõnesid vahemällu salvestada kasutaja lokaadi alusel. Saate kasutada WeakMap'i vahemälu salvestamiseks, kus võtmeks on lokaadi objekt ja väärtuseks selle lokaadi tõlgitud sõned. Kui lokaati enam ei vajata (nt kasutaja vahetab keelt ja vanale lokaadile enam ei viidata), prügikoristatakse selle lokaadi vahemälu automaatselt.

            let i18nCache = new WeakMap();

function getTranslatedStrings(locale) {
  if (i18nCache.has(locale)) {
    return i18nCache.get(locale);
  }

  // Simuleerime tõlgitud sõnede toomist serverist.
  let translatedStrings = {
    "greeting": (locale.language === "fr") ? "Bonjour" : "Hello",
    "farewell": (locale.language === "fr") ? "Au revoir" : "Goodbye"
  };

  i18nCache.set(locale, translatedStrings);
  return translatedStrings;
}

let englishLocale = { language: "en", country: "US" };
let frenchLocale = { language: "fr", country: "FR" };

console.log(getTranslatedStrings(englishLocale).greeting); // Output: Hello
console.log(getTranslatedStrings(frenchLocale).greeting);  // Output: Bonjour

englishLocale = null;

// Pärast prügikoristust eemaldatakse englishLocale kirje vahemälust.

            

              
                Copy
              
            
          

See lähenemine takistab i18n vahemälu lõputut kasvamist ja liigse mälu tarbimist, eriti rakendustes, mis toetavad suurt hulka lokaate.

Kokkuvõte

WeakMap ja WeakSet on võimsad tööriistad mälu haldamiseks JavaScripti rakendustes. Mõistes nende piiranguid ja kasutusjuhte, saate kirjutada tõhusamat ja robustsemat koodi, mis väldib mälulekkeid. Kuigi need ei pruugi sobida igaks stsenaariumiks, on need hädavajalikud olukordades, kus peate seostama andmeid objektidega, takistamata nende objektide prügikoristamist. Võtke need kollektsioonid omaks, et optimeerida oma JavaScripti rakendusi ja luua parem kasutajakogemus oma kasutajatele, olenemata sellest, kus nad maailmas asuvad.